// internal/apps/auth/controllers/user_controller.go
package controllers

import (
	"strconv"

	"star-go-app/internal/apps/auth/repositories"
	"star-go-app/internal/apps/auth/serializers"
	"star-go-app/internal/apps/auth/services"
	"star-go-app/pkg/common/utils/response"
	"star-go-app/pkg/infra/logger"

	"github.com/gin-gonic/gin"
	"go.uber.org/zap"
)

// UserController 用户控制器
type UserController struct {
	userService *services.UserService
}

// NewUserController 创建用户控制器
func NewUserController() *UserController {
	userRepo := repositories.NewUserRepository()
	userService := services.NewUserService(userRepo)

	return &UserController{
		userService: userService,
	}
}

// CreateUser 创建用户
// @Summary 创建用户
// @Description 创建新用户
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param request body serializers.CreateUserRequest true "创建用户请求"
// @Success 200 {object} response.Response{data=serializers.UserResponse} "创建成功"
// @Failure 400 {object} response.Response "请求参数错误"
// @Failure 500 {object} response.Response "内部服务器错误"
// @Router /api/auth/users [post]
func (uc *UserController) CreateUser(c *gin.Context) {
	var req serializers.CreateUserRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.GetLogger().Error("绑定创建用户请求参数失败", zap.Error(err))
		response.FailWithMessage(c, response.INVALID_PARAMS, "请求参数错误: "+err.Error(), nil)
		return
	}

	user, err := uc.userService.CreateUser(&req)
	if err != nil {
		logger.GetLogger().Error("创建用户失败", zap.Error(err))
		response.FailWithMessage(c, response.ERROR, err.Error(), nil)
		return
	}

	logger.GetLogger().Info("用户创建成功", zap.String("username", user.Username))
	response.SuccessWithMessage(c, "用户创建成功", user)
}

// GetUserByID 根据ID获取用户
// @Summary 获取用户详情
// @Description 根据ID获取用户详情信息
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param id path int true "用户ID"
// @Success 200 {object} response.Response{data=serializers.UserDetailResponse} "获取成功"
// @Failure 400 {object} response.Response "请求参数错误"
// @Failure 404 {object} response.Response "用户不存在"
// @Failure 500 {object} response.Response "内部服务器错误"
// @Router /api/auth/users/{id} [get]
func (uc *UserController) GetUserByID(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.FailWithMessage(c, response.INVALID_PARAMS, "用户ID格式错误", nil)
		return
	}

	user, err := uc.userService.GetUserByID(uint(id))
	if err != nil {
		logger.GetLogger().Error("获取用户失败", zap.Error(err), zap.Uint64("id", id))
		response.FailWithMessage(c, response.NOT_FOUND, "用户不存在", nil)
		return
	}

	response.SuccessWithMessage(c, "获取用户成功", user)
}

// GetUserList 获取用户列表
// @Summary 获取用户列表
// @Description 分页获取用户列表
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param page query int false "页码" default(1)
// @Param page_size query int false "每页数量" default(10)
// @Param username query string false "用户名筛选"
// @Param email query string false "邮箱筛选"
// @Param role_id query int false "角色ID筛选"
// @Success 200 {object} response.Response{data=serializers.UserListResponse} "获取成功"
// @Failure 400 {object} response.Response "请求参数错误"
// @Failure 500 {object} response.Response "内部服务器错误"
// @Router /api/auth/users [get]
func (uc *UserController) GetUserList(c *gin.Context) {
	var req serializers.UserListRequest
	if err := c.ShouldBindQuery(&req); err != nil {
		logger.GetLogger().Error("绑定用户列表查询参数失败", zap.Error(err))
		response.FailWithMessage(c, response.INVALID_PARAMS, "请求参数错误: "+err.Error(), nil)
		return
	}

	// 设置默认值
	if req.Page <= 0 {
		req.Page = 1
	}
	if req.PageSize <= 0 {
		req.PageSize = 10
	}
	if req.PageSize > 100 {
		req.PageSize = 100
	}

	userList, err := uc.userService.GetUserList(&req)
	if err != nil {
		logger.GetLogger().Error("获取用户列表失败", zap.Error(err))
		response.FailWithMessage(c, response.ERROR, err.Error(), nil)
		return
	}

	response.SuccessWithMessage(c, "获取用户列表成功", userList)
}

// UpdateUser 部分更新用户
// @Summary 部分更新用户
// @Description 部分更新用户信息
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param id path int true "用户ID"
// @Param request body serializers.UpdateUserRequest true "更新用户请求"
// @Success 200 {object} response.Response{data=serializers.UserResponse} "更新成功"
// @Failure 400 {object} response.Response "请求参数错误"
// @Failure 404 {object} response.Response "用户不存在"
// @Failure 500 {object} response.Response "内部服务器错误"
// @Router /api/auth/users/{id} [put]
func (uc *UserController) UpdateUser(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.FailWithMessage(c, response.INVALID_PARAMS, "用户ID格式错误", nil)
		return
	}

	var req serializers.UpdateUserRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.GetLogger().Error("绑定更新用户请求参数失败", zap.Error(err))
		response.FailWithMessage(c, response.INVALID_PARAMS, "请求参数错误: "+err.Error(), nil)
		return
	}

	user, err := uc.userService.UpdateUser(uint(id), &req)
	if err != nil {
		logger.GetLogger().Error("更新用户失败", zap.Error(err), zap.Uint64("id", id))
		response.FailWithMessage(c, response.ERROR, err.Error(), nil)
		return
	}

	logger.GetLogger().Info("用户更新成功", zap.Uint64("id", id))
	response.SuccessWithMessage(c, "用户更新成功", user)
}

// UpdateUserWhole 完整更新用户
// @Summary 完整更新用户
// @Description 完整更新用户信息
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param id path int true "用户ID"
// @Param request body serializers.UpdateUserWholeRequest true "完整更新用户请求"
// @Success 200 {object} response.Response{data=serializers.UserResponse} "更新成功"
// @Failure 400 {object} response.Response "请求参数错误"
// @Failure 404 {object} response.Response "用户不存在"
// @Failure 500 {object} response.Response "内部服务器错误"
// @Router /api/auth/users/{id}/whole [put]
func (uc *UserController) UpdateUserWhole(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.FailWithMessage(c, response.INVALID_PARAMS, "用户ID格式错误", nil)
		return
	}

	var req serializers.UpdateUserWholeRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.GetLogger().Error("绑定完整更新用户请求参数失败", zap.Error(err))
		response.FailWithMessage(c, response.INVALID_PARAMS, "请求参数错误: "+err.Error(), nil)
		return
	}

	user, err := uc.userService.UpdateUserWhole(uint(id), &req)
	if err != nil {
		logger.GetLogger().Error("完整更新用户失败", zap.Error(err), zap.Uint64("id", id))
		response.FailWithMessage(c, response.ERROR, err.Error(), nil)
		return
	}

	logger.GetLogger().Info("用户完整更新成功", zap.Uint64("id", id))
	response.SuccessWithMessage(c, "用户更新成功", user)
}

// DeleteUser 软删除用户
// @Summary 软删除用户
// @Description 软删除用户（可恢复）
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param id path int true "用户ID"
// @Success 200 {object} response.Response "删除成功"
// @Failure 400 {object} response.Response "请求参数错误"
// @Failure 404 {object} response.Response "用户不存在"
// @Failure 500 {object} response.Response "内部服务器错误"
// @Router /api/auth/users/{id} [delete]
func (uc *UserController) DeleteUser(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.FailWithMessage(c, response.INVALID_PARAMS, "用户ID格式错误", nil)
		return
	}

	if err := uc.userService.DeleteUser(uint(id)); err != nil {
		logger.GetLogger().Error("删除用户失败", zap.Error(err), zap.Uint64("id", id))
		response.FailWithMessage(c, response.ERROR, err.Error(), nil)
		return
	}

	logger.GetLogger().Info("用户删除成功", zap.Uint64("id", id))
	response.SuccessWithMessage(c, "用户删除成功", nil)
}

// DeleteUserPermanently 永久删除用户
// @Summary 永久删除用户
// @Description 永久删除用户（不可恢复）
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param id path int true "用户ID"
// @Success 200 {object} response.Response "删除成功"
// @Failure 400 {object} response.Response "请求参数错误"
// @Failure 404 {object} response.Response "用户不存在"
// @Failure 500 {object} response.Response "内部服务器错误"
// @Router /api/auth/users/{id}/true [delete]
func (uc *UserController) DeleteUserPermanently(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.FailWithMessage(c, response.INVALID_PARAMS, "用户ID格式错误", nil)
		return
	}

	if err := uc.userService.DeleteUserPermanently(uint(id)); err != nil {
		logger.GetLogger().Error("永久删除用户失败", zap.Error(err), zap.Uint64("id", id))
		response.FailWithMessage(c, response.ERROR, err.Error(), nil)
		return
	}

	logger.GetLogger().Info("用户永久删除成功", zap.Uint64("id", id))
	response.SuccessWithMessage(c, "用户永久删除成功", nil)
}

// ChangePassword 修改密码
// @Summary 修改用户密码
// @Description 修改用户密码
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param id path int true "用户ID"
// @Param request body serializers.ChangePasswordRequest true "修改密码请求"
// @Success 200 {object} response.Response "修改成功"
// @Failure 400 {object} response.Response "请求参数错误"
// @Failure 404 {object} response.Response "用户不存在"
// @Failure 500 {object} response.Response "内部服务器错误"
// @Router /api/auth/users/{id}/password [put]
func (uc *UserController) ChangePassword(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.FailWithMessage(c, response.INVALID_PARAMS, "用户ID格式错误", nil)
		return
	}

	var req serializers.ChangePasswordRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.GetLogger().Error("绑定修改密码请求参数失败", zap.Error(err))
		response.FailWithMessage(c, response.INVALID_PARAMS, "请求参数错误: "+err.Error(), nil)
		return
	}

	if err := uc.userService.ChangePassword(uint(id), &req); err != nil {
		logger.GetLogger().Error("修改密码失败", zap.Error(err), zap.Uint64("id", id))
		response.FailWithMessage(c, response.ERROR, err.Error(), nil)
		return
	}

	logger.GetLogger().Info("密码修改成功", zap.Uint64("id", id))
	response.SuccessWithMessage(c, "密码修改成功", nil)
}
